home *** CD-ROM | disk | FTP | other *** search
/ Plug-In Power Pack for Netscape Communicator / Plug-In Power Pack for Netscape Communicator.iso / plugins / dataviews / dvtools / demos / citydemo / c4i_dsp.c < prev    next >
C/C++ Source or Header  |  1997-05-08  |  16KB  |  521 lines
  1. #ifndef lint
  2. static char SccsId[]= "@(#)c4i_dsp.c    V1.24    4/13/95";
  3. #endif
  4.  
  5. /*------------------------------------------------------------------
  6. | file name -- c4i_dsp.c
  7. |
  8. | functions        Description
  9. | ---------             -----------
  10. | InitDisplays        Initializes the SCREEN and DRAWPORTS
  11. | TermDisplays           Cleans up the SCREEN, DRAWPORTS and DISPLAY_LIST
  12. |
  13. | OverlayDisplay        Overlay the view.
  14. | RemoveDisplay         Deletes the overlayed view.
  15. |
  16. | Get_Drawport        Returns the previously or newly created drawport.
  17. |
  18. | preload_views        Preloads all views... (base and overlays)
  19. | create_drawport    Creates the drawport and adds it to the table
  20. | next_display       Adds a display to the list.
  21. | create_display_list   Create a DisplayList for NEXT/PREV.
  22. | del_display_list_item    Delete a display from the DisplayList.
  23. | destroy_display_list  Destroys the DisplayList.
  24. |
  25. |-----------------------------------------------------------------*/
  26.  
  27. #include "std.h"
  28. #include "dvstd.h"
  29. #include "dvGR.h"
  30. #include "VOstd.h"
  31. #include "Tfundecl.h"
  32. #include "c4i_vars.h"
  33. #include "GRfundecl.h"
  34. #include "VOfundecl.h"
  35. #include "VTfundecl.h"
  36. #include "c4i_fundecl.h"
  37.  
  38.  
  39.  
  40.  
  41. #define NEW_LIST        (char)0
  42. #define ADD_TO_LIST        (char)1
  43. #define DELETE_FROM_LIST    (char)2
  44.  
  45. extern FLOAT Intro1;         /* For controlling introduction view... */
  46.  
  47. /***************** Begin Function Declarations *************/
  48. LOCAL  void preload_views V_P_((void));
  49. LOCAL  DRAWPORT create_drawport V_P_((OBJECT screen, char *viewname,
  50.                       BOOLPARAM stretch,
  51.                       RECTANGLE *vvp, RECTANGLE *wvp));
  52. LOCAL  DRAWPORT next_display V_P_((char *view_name));
  53. LOCAL  DISPLAY_LIST *create_display_list V_P_((void));
  54. LOCAL  void del_display_list_item V_P_((DISPLAY_LIST *display_item));
  55. LOCAL  void destroy_display_list V_P_((DISPLAY_LIST **display_info));
  56. /***************** End Function Declarations *************/
  57. CHAR *VIstrclone ();          /* Internal function: allocates & copies a string */
  58. /*-----------------------------------------------------------------
  59. |
  60. |  InitDisplays
  61. |       Performs the initialization needed for the display.
  62. |
  63. |       A SCREEN is opened using DVDEVICE and other attributes.
  64. |
  65. |    create_drawport() is called to create a drawport for each
  66. |    display area. create_drawport will be called each time a
  67. |    a new views is needed by the display manager.
  68. */
  69. void
  70. InitDisplays V_P_ ((void))
  71. {
  72.  
  73.   DRAWPORT control_dp;
  74.   OBJECT screen;
  75.  
  76.   /* Create view and drawport tables needed from display management */
  77.   ViewTable = VTstsizecreate ("View Names and VIEWs", (VTSTCOMPAREFUNPTR)NULL,
  78.                               VTABLE_LEN);
  79.   DpTable = VTstsizecreate ("View Names and DRAWPORTs",(VTSTCOMPAREFUNPTR)NULL,
  80.                             DPTABLE_LEN);
  81.   /* Open the MAIN window */
  82.   screen = OpenWindow (MAIN_WINDOW);
  83.   EXIT_IF_INVALID (screen, NO_DEVICE);
  84.  
  85.   /* Draw the main Map */
  86.   (VOID) create_drawport (DVscreen[MAIN_WINDOW], MAP_VIEW,
  87.                           PreldView[0].CreateStretch,
  88.                           DEFAULT_SIZE, DEFAULT_PORTION);
  89.   ActiveDrawport = next_display (MAP_VIEW);
  90.   EXIT_IF_INVALID (ActiveDrawport, NO_MAP_VIEW);
  91.   TdpDraw (ActiveDrawport);
  92.  
  93.   /* Open the CONTROL window */
  94.   screen = OpenWindow (CONTROL_WINDOW);
  95.   EXIT_IF_INVALID (screen, NO_DEVICE);
  96.   control_dp = Get_Drawport (CONTROL_VIEW,
  97.                              DVscreen[CONTROL_WINDOW], NO_STRETCH,
  98.                              DEFAULT_SIZE, DEFAULT_PORTION);
  99.   EXIT_IF_INVALID (control_dp, NO_CONTROL_VIEW);
  100.   (VOID) TdpDraw (control_dp);
  101.  
  102.   /* Set the active screen to the main window */
  103.   (VOID) TscSetCurrentScreen (DVscreen[MAIN_WINDOW]);
  104.   ActiveScreenIndex = MAIN_WINDOW;
  105.  
  106.   /* Preload all the views */
  107.   preload_views ();
  108.  
  109.   /* Intialize information for zooming and panning. */
  110.   InitZoomInfo ();
  111.   ZoomeD = 0;                   /* indicates we start in an unzoomed state */
  112.  
  113.   /* Create pop-up drawports for the MAIN_WINDOW */
  114.   CreatePopupDps ();
  115.  
  116.   /* Now that we are ready, reset the cursors */
  117.   TscSetCurrentScreen (DVscreen[MAIN_WINDOW]);
  118.   (VOID) GRset (V_ACTIVE_CURSOR, V_END_OF_LIST);
  119.   TscSetCurrentScreen (DVscreen[CONTROL_WINDOW]);
  120.   (VOID) GRset (V_ACTIVE_CURSOR, V_END_OF_LIST);
  121.  
  122. }
  123.  
  124. /*-----------------------------------------------------------------
  125. |
  126. |  OverlayDisplay
  127. |    Tries to overlay a view to the current display.  The
  128. |    named view is merged to the existing drawing.
  129. |
  130. */
  131. void 
  132. OverlayDisplay (view_name, dsl_merge_required)
  133.      char *view_name;
  134.      int dsl_merge_required;
  135. {
  136.   VIEW overlay_view, main_view;
  137.   OBJECT overlay_drawing, obj_dq;
  138.   INT i, num_objs;
  139.  
  140.   DATASOURCELIST main_dsl;
  141.  
  142.   overlay_view = Get_View (view_name, ADD);
  143.   if (overlay_view)
  144.     {
  145.       /* Get the overlay drawing and the active view */
  146.       overlay_drawing = TviGetDrawing (overlay_view);
  147.       main_view = TdpGetView (ActiveDrawport);
  148.  
  149.       /* Merge the overlay into the active view */
  150.       (VOID) TviMergeDrawing (main_view, overlay_drawing);
  151.  
  152.       if (dsl_merge_required)
  153.         {
  154.           main_dsl = TviGetDataSourceList (main_view);
  155.           (VOID) TviMergeAddDataSources (overlay_view, main_dsl, DS_NAMEMATCH);
  156.         }
  157.  
  158.       /* Draw the objects in the overlay view */
  159.       obj_dq = VOdrGetObjectDeque (overlay_drawing);
  160.       num_objs = VOdqSize (obj_dq);
  161.       for (i = 1; i <= num_objs; i++)
  162.         (VOID) TdpDrawObject (ActiveDrawport, VOdqGetEntry (obj_dq, i));
  163.  
  164.     }
  165. }
  166.  
  167. /*-----------------------------------------------------------------
  168. |
  169. |  RemoveDisplay
  170. |    Tries to delete the named view from the current display. The
  171. |    named view is excised from the existing drawing.
  172. |
  173. */
  174. void 
  175. RemoveDisplay (view_name)
  176.      char *view_name;
  177. {
  178.   VIEW overlay_view, main_view;
  179.   OBJECT overlay_drawing, obj_dq, obj;
  180.   INT i, num_objs;
  181.   RECTANGLE bounding_box, scr_offset, scr_box;
  182.   BOOLPARAM obj_is_visible;
  183.   CHAR *obj_name;
  184.  
  185.   overlay_view = Get_View (view_name, ADD);
  186.   if (overlay_view)
  187.     {
  188.       /* Get the overlay drawing and the active view */
  189.       overlay_drawing = TviGetDrawing (overlay_view);
  190.       main_view = TdpGetView (ActiveDrawport);
  191.  
  192.       /* Delete the overlay from the active view */
  193.       num_objs = TviExciseDrawing (main_view, overlay_drawing);
  194.       if (num_objs != 0)
  195.         {
  196.           /* Erase the overlay view */
  197.           obj_dq = VOdrGetObjectDeque (overlay_drawing);
  198.           num_objs = VOdqSize (obj_dq);
  199.           for (i = num_objs; i >= 1; i--)
  200.             {
  201.               obj = VOdqGetEntry (obj_dq, i);
  202.               obj_name = TdrGetObjectName (overlay_drawing, obj);
  203.               obj_is_visible = YES;
  204.               if (obj_name && *obj_name == INVISIBLE)
  205.                 obj_is_visible = NO;
  206.  
  207.               /* If we don't have an input object and the object IS visible
  208.               |  restore the screen area, below the erased object */
  209.               if (obj_is_visible)
  210.                 {
  211.                   if (VOobType (obj) == OT_INPUT)
  212.                     (VOID) TdpEraseObject (ActiveDrawport, obj);
  213.                   else
  214.                     {
  215.                       /* Erasing an object destroys box info, so get it before erasing */
  216.                       (VOID) VOobBox (obj, &bounding_box, &scr_offset);
  217.                       (VOID) TdpWorldToScreen (ActiveDrawport,
  218.                                        &bounding_box.ll, &scr_box.ll);
  219.                       (VOID) TdpWorldToScreen (ActiveDrawport,
  220.                                        &bounding_box.ur, &scr_box.ur);
  221.                       scr_box.ll.x += scr_offset.ll.x;
  222.                       scr_box.ll.y += scr_offset.ll.y;
  223.                       scr_box.ur.x += scr_offset.ur.x;
  224.                       scr_box.ur.y += scr_offset.ur.y;
  225.  
  226.                       (VOID) TdpEraseObject (ActiveDrawport, obj);
  227.                       (VOID) TdpRedraw (ActiveDrawport, &scr_box, NO);
  228.                     }
  229.                 }
  230.             }
  231.         }
  232.     }
  233. }
  234.  
  235. /*-----------------------------------------------------------------
  236. |
  237. |  preload_views
  238. |       The function Pre-Loads the views....of the MAINWINDOW
  239. */
  240. LOCAL void
  241. preload_views V_P_ ((void))
  242. {
  243.   INT i;
  244.  
  245.   /* For all the preload views... load the view, create a drawport, add the
  246.   |  drawport to the symbol table. NOTE: we start at index =1 because
  247.   |  the top view is already loaded and visible.
  248.   */
  249.   for (i = 1; i < NUM_VU_PRELOAD; i++)
  250.     {
  251.       (VOID) create_drawport (DVscreen[MAIN_WINDOW], PreldView[i].name,
  252.                               PreldView[i].CreateStretch,
  253.                               DEFAULT_SIZE, DEFAULT_PORTION);
  254.  
  255.     }
  256.  
  257. }
  258.  
  259.  
  260. /*-----------------------------------------------------------------
  261. |
  262. |  create_drawport
  263. |       The function loads the view (viewname) and creates a drawport
  264. |    in the (screen) using the (vvp) and (wvp) to determine how to
  265. |    display the view.
  266. |
  267. |       The drawport is added to the symbol tables for easy access by the
  268. |    display manager routines.  Drawports are referenced by their view
  269. |    name.
  270. |
  271. |    We call SetupButton() to setup event handling for the buttons
  272. |    embedded in the views.
  273. |
  274. |       We call RebindData() for all the dynamic objects. This will
  275. |       see if the variable is being controlled by the application and
  276. |       rebind it if necessary.
  277. |
  278. */
  279. LOCAL DRAWPORT 
  280. create_drawport (screen, viewname, stretch, vvp, wvp)
  281.      OBJECT screen;
  282.      char *viewname;
  283.      BOOLPARAM stretch;
  284.      RECTANGLE *vvp;
  285.      RECTANGLE *wvp;
  286. {
  287.   VIEW view;
  288.   OBJECT drawing, color;
  289.   DRAWPORT drawport = NULL;
  290.  
  291.   /* Load the view */
  292.   view = TviLoad (viewname);
  293.  
  294.   if (view)
  295.     {
  296.       /* Create the Drawport */
  297.       if (stretch)
  298.         drawport = TdpCreateStretch (screen, view, vvp, wvp);
  299.       else
  300.         drawport = TdpCreate (screen, view, vvp, wvp);
  301.  
  302.       /* Add the drawport to the table */
  303.       (VOID) VTstsninsert (DpTable, VIstrclone (viewname), (INT *) drawport);
  304.  
  305.       /* Setup the callbacks for the buttons */
  306.       SetupButtons (view);      /* found in c4i_events.c */
  307.  
  308.       /* Rebind the dyanmic object's variables to real-time data  */
  309.       RebindData (view);        /* found in c4i_rebind.c */
  310.  
  311.       /* Set the off drawing color to match the drawing's background
  312.       | color.  This will help the Zooming/Panning of the drawing
  313.       | look better */
  314.       if (S_STRCMP (viewname, MAP_VIEW) == 0)
  315.         {
  316.           drawing = TviGetDrawing (view);
  317.           color = VOdrBackcolor (drawing, (OBJECT) DONT_SET_THE_VALUE);
  318.           (VOID) VOdrOffcolor (color);
  319.         }
  320.     }
  321.   return drawport;
  322. }
  323.  
  324. /*-----------------------------------------------------------------
  325. |
  326. |  Get_Drawport
  327. |       Returns the drawport associated with the view_name. If the
  328. |       drawport doesn't exist, it creates one using create_drawport().
  329. */
  330. DRAWPORT 
  331. Get_Drawport (view_name, screen, stretch, vvp, wvp)
  332.      char *view_name;
  333.      OBJECT screen;
  334.      BOOLPARAM stretch;
  335.      RECTANGLE *vvp;
  336.      RECTANGLE *wvp;
  337. {
  338.   SYMNODE key;
  339.  
  340.   /* See if the drawport is already in the Drawport Table */
  341.   key = VTstkeyfind (DpTable, view_name);
  342.   if (key)
  343.     return (DRAWPORT) VTsnvalue (key);
  344.   else
  345.     return create_drawport (screen, view_name, stretch, vvp, wvp);
  346. }
  347.  
  348. /*-----------------------------------------------------------------
  349. |
  350. |  next_display
  351. |    Tries to add a display to the DisplayList. If the view can't
  352. |    be displayed, returns DV_FAILURE, else DV_SUCCESS.
  353. |
  354. |    NOTE:
  355. |    In this application, there is only one map to select.  This
  356. |    DisplayList management algorithm is more useful for cases where
  357. |    there are more than one map (or view) from which to choose.
  358. |    This application is therefore expandable through the addition of
  359. |    more maps (views).
  360. |
  361. |
  362. */
  363. LOCAL DRAWPORT 
  364. next_display (view_name)
  365.      char *view_name;
  366. {
  367.   INT i;
  368.  
  369.   DISPLAY_LIST *prev_display;
  370.   DRAWPORT dp;
  371.  
  372.   /* Get the drawport associated with the view */
  373.   dp = Get_Drawport (view_name, DVscreen[MAIN_WINDOW], NO_STRETCH,
  374.                      DEFAULT_SIZE, DEFAULT_PORTION);
  375.  
  376.   if (dp)
  377.     {
  378.       /* If the list doesn't exist yet, create it.
  379.       |
  380.       |  Make the current list top the previous display. Then,
  381.       |  make the new display the list top. */
  382.       if (!DisplayList)
  383.         {
  384.           prev_display = create_display_list ();
  385.           prev_display->drawport = ActiveDrawport;
  386.           prev_display->zoomed = ZoomeD;
  387.         }
  388.       else
  389.         prev_display = DisplayList;
  390.  
  391.       DisplayList = create_display_list ();
  392.       DisplayList->drawport = dp;
  393.       DisplayList->prev = prev_display;
  394.       for (i = 0; i < 4; i++)
  395.         DisplayList->overlays[i] = NO;
  396.       DisplayList->zoomed = ZoomeD;
  397.  
  398.       /*init POPUP_VIEWLIST structure. */
  399.       for (i = 0; i < NUM_POPUP_DP; i++)
  400.         DisplayList->PopupDp[i] = NULL;
  401.  
  402.     }
  403.   return (dp);
  404.  
  405.  
  406. }
  407.  
  408.  
  409. /*-----------------------------------------------------------------
  410. |
  411. |  create_display_list - Allocates and initializes a DISPLAY_LIST.
  412. */
  413. LOCAL DISPLAY_LIST *create_display_list 
  414. V_P_ ((void))
  415. {
  416.   DISPLAY_LIST *display_info;
  417.  
  418.   display_info = (DISPLAY_LIST *) S_ALLOC ((LONG) sizeof (DISPLAY_LIST));
  419.   display_info->drawport = (DRAWPORT) NULL;
  420.   display_info->prev = (DISPLAY_LIST *) NULL;
  421.   return display_info;
  422. }
  423.  
  424. /*-----------------------------------------------------------------
  425. |
  426. |  del_display_list_item - Frees a DISPLAY_LIST item.
  427. */
  428. LOCAL void 
  429. del_display_list_item (display_item)
  430.      DISPLAY_LIST *display_item;
  431. {
  432.   (VOID) S_FREE ((CHAR *) display_item);
  433. }
  434.  
  435. /*-----------------------------------------------------------------
  436. |
  437. |  destroy_display_list - Destroys the DISPLAY_LIST by freeing each item.
  438. */
  439. LOCAL void 
  440. destroy_display_list (display_info)
  441.      DISPLAY_LIST **display_info;
  442. {
  443.   DISPLAY_LIST *info, *prev;
  444.  
  445.   info = *display_info;
  446.   while (info)
  447.     {
  448.       prev = info->prev;
  449.       del_display_list_item (info);
  450.       info = prev;
  451.     }
  452.   *display_info = NULL;
  453. }
  454.  
  455. /*-----------------------------------------------------------------
  456. |
  457. |  TermDisplays
  458. |       Performs the termination and clean up needed for the display
  459. |    components. This balances InitDisplays().
  460. |
  461. |    The Drawport and View Tables are "traversed" to clean up
  462. |    the views and drawports.  We also clean up the table as we go.
  463. |    The AreaCoords used to define drawport areas are "freed". The
  464. |    display manager's DisplayList is destroyed. Finally, the screen
  465. |    is erased and closed.
  466. */
  467. void TermDisplays 
  468. V_P_ ((void))
  469. {
  470.   INT i;
  471.   CHAR *viewname;
  472.   SYMNODE node;
  473.   VIEW view;
  474.   DRAWPORT dp;
  475.  
  476.   /* Destroy the display drawports */
  477.   while (VTstlen (DpTable) > 0)
  478.     {
  479.       node = VTstsnget (DpTable, 0);
  480.       viewname = VTsnkey (node);
  481.       S_FREE (viewname);
  482.       dp = (DRAWPORT) VTsnvalue (node);
  483.       view = TdpGetView (dp);
  484.       (VOID) TdpDestroy (dp);
  485.       (VOID) TviDestroy (view);
  486.       dp = (DRAWPORT) NULL;
  487.       VTstsnremove (DpTable, node);
  488.     }
  489.   VTstdestroy (DpTable);
  490.  
  491.   /* Destroy the overlay views */
  492.   while (VTstlen (ViewTable) > 0)
  493.     {
  494.       node = VTstsnget (ViewTable, 0);
  495.       viewname = VTsnkey (node);
  496.       S_FREE (viewname);
  497.       (VOID) TviDestroy ((VIEW) VTsnvalue (node));
  498.       VTstsnremove (ViewTable, node);
  499.     }
  500.   VTstdestroy (ViewTable);
  501.  
  502.   /* Destroy the Calculating Drawports */
  503.   view = TdpGetView (CalculatingDp[OF_UNZOOMED_VIEW]);
  504.   (VOID) TdpDestroy (CalculatingDp[OF_UNZOOMED_VIEW]);
  505.   (VOID) TviDestroy (view);
  506.  
  507.   view = TdpGetView (CalculatingDp[OF_ZOOMED_VIEW]);
  508.   (VOID) TdpDestroy (CalculatingDp[OF_ZOOMED_VIEW]);
  509.   (VOID) TviDestroy (view);
  510.  
  511.  
  512.   /* Destroy the Display List */
  513.   destroy_display_list (&DisplayList);
  514.  
  515.   /* Destroy, Erase and Close the Windows */
  516.   for (i = 0; i < NUM_WINDOWS; i++)
  517.     CleanupWindow (i);
  518. }
  519.  
  520. /* END TERMDISPLAYS */
  521.